home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Telnet 2.7b5 / source / config / configure.c next >
Encoding:
C/C++ Source or Header  |  1995-06-08  |  49.8 KB  |  1,598 lines  |  [TEXT/CWIE]
  1. /*    Configure.c
  2. *    New Configuration scheme (the death of config.tel)
  3. *
  4. *****************************************************************
  5. *    NCSA Telnet for the Macintosh                                *
  6. *                                                                *
  7. *    National Center for Supercomputing Applications                *
  8. *    Software Development Group                                    *
  9. *    152 Computing Applications Building                            *
  10. *    605 E. Springfield Ave.                                        *
  11. *    Champaign, IL  61820                                        *
  12. *                                                                *
  13. *    Copyright (c) 1986-1993,                                    *
  14. *    Board of Trustees of the University of Illinois                *
  15. *****************************************************************
  16. *  Revisions:
  17. *  8/92        Telnet 2.6:    Initial version.  Jim Browne
  18. */
  19.  
  20. #ifdef MPW
  21. #pragma segment Configure
  22. #endif
  23.  
  24.  
  25.  
  26. #include "DlogUtils.proto.h"
  27. #include "popup.h"
  28. #include "popup.proto.h"
  29. #include "configure.proto.h"
  30. #include "netevent.proto.h"        /* For Stask proto */
  31. #include "prefs.proto.h"
  32. #include "bkgr.proto.h"            // For StartUpFTP proto
  33. #include "menuseg.proto.h"
  34. #include "macutil.proto.h"        
  35. #include "rsinterf.proto.h"
  36. #include "LinkedList.proto.h"
  37.  
  38. static Boolean isACopy(Str255 theName);//looks for an occurance of "copy" in a string
  39.  
  40. static    pascal short TerminalModalProc( DialogPtr dptr, EventRecord *evt, short *item);
  41. PROTO_UPP(TerminalModalProc, ModalFilter);
  42. static    pascal short SessionModalProc(DialogPtr dptr, EventRecord *evt, short *item);
  43. PROTO_UPP(SessionModalProc, ModalFilter);
  44. static    pascal short MyDlogWListFilter( DialogPtr dptr, EventRecord *evt, short *item);
  45. PROTO_UPP(MyDlogWListFilter, ModalFilter);
  46.  
  47. static    pascal void    listDitemproc(DialogPtr theDlg, short itemNo);
  48. PROTO_UPP(listDitemproc, UserItem);
  49.  
  50. extern    FTPServerPrefs*        gFTPServerPrefs;
  51. extern    ApplicationPrefs*    gApplicationPrefs;
  52. extern    MenuHandle    myMenus[];
  53. static    void ZeroNumOnly(void);
  54. static    Boolean InNumOnly(short item);
  55.  
  56. static LinkedListNode *currentHead;
  57. static ListHandle currentList;
  58. #define NUMONLYSIZE 8
  59. short NumOnly[NUMONLYSIZE];        /* Items for which non-number keys are ignored */
  60.                                 // NumOnly[0] is number of "safe" item to return
  61.  
  62. void    CONFIGUREunload(void) {}
  63.                         
  64. void Cenviron( void)
  65. {
  66.     DialogPtr    dptr;
  67.     short         ditem;
  68.     Str255        scratchPstring;
  69.     long         scratchlong;
  70.     OSType        newtype;
  71.     PaletteHandle toSave;
  72.     Boolean        tempBoolean;
  73.     
  74.     dptr = GetNewMySmallStrangeDialog( PrefDLOG, NULL, kInFront, (void *)ThirdCenterDialog);    
  75.     
  76.     SetCntrl(dptr, PrefDClose, gApplicationPrefs->WindowsDontGoAway);
  77.     SetCntrl(dptr, PrefStag, gApplicationPrefs->StaggerWindows);
  78.     if (!gApplicationPrefs->StaggerWindows)
  79.     {
  80.         HideDItem(dptr,PrefStaggerOffset);
  81.         HideDItem(dptr,PrefStaggerBY);
  82.         tempBoolean = FALSE;
  83.     }
  84.     else
  85.     {
  86.         scratchlong = gApplicationPrefs->StaggerWindowsOffset;
  87.         NumToString(scratchlong, scratchPstring);
  88.         SetTEText(dptr, PrefStaggerOffset, scratchPstring);
  89.         tempBoolean = TRUE;
  90.     }
  91.     if (!TelInfo->haveColorQuickDraw)
  92.         HideDItem(dptr,PrefAnsiColor);
  93.         
  94.     SetCntrl(dptr, PrefCMDkey, gApplicationPrefs->CommandKeys);
  95.     SetCntrl(dptr, PrefTMap, gApplicationPrefs->RemapTilde);
  96.     SetCntrl(dptr, PrefBlink, gApplicationPrefs->BlinkCursor);
  97.     SetCntrl(dptr, PrefKeyFuncMenus, gApplicationPrefs->KeyPadAndFuncMenus);
  98.     SetCntrl(dptr, PrefNotifyUser, gApplicationPrefs->NotifyUser);
  99.     SetCntrl(dptr, PrefBlockCursor, (gApplicationPrefs->CursorType == 0));
  100.     SetCntrl(dptr, PrefUnderscoreCursor, (gApplicationPrefs->CursorType == 1));
  101.     SetCntrl(dptr, PrefVerticalCursor, (gApplicationPrefs->CursorType == 2));
  102.     SetCntrl(dptr, PrefDestroyTickets, gApplicationPrefs->destroyKTickets);
  103.     scratchPstring[0] = 4;
  104.     BlockMove(&(gApplicationPrefs->CaptureFileCreator), &scratchPstring[1], sizeof(OSType));
  105.     SetTEText(dptr, PrefCaptTE, scratchPstring);
  106.     newtype = gApplicationPrefs->CaptureFileCreator;
  107.  
  108.     scratchlong = gApplicationPrefs->CopyTableThresh;
  109.     NumToString(scratchlong, scratchPstring);
  110.     SetTEText(dptr, PrefCTt, scratchPstring);
  111.     SelIText(dptr, PrefCTt, 0, 32767);
  112.  
  113.     NumToString(gApplicationPrefs->TimeSlice, scratchPstring);
  114.     SetTEText(dptr, PrefTimeSlice, scratchPstring);
  115.     
  116.     scratchlong = (long) gApplicationPrefs->OpenTimeout;
  117.     NumToString(scratchlong,scratchPstring);
  118.     SetTEText(dptr,PrefOpenTime, scratchPstring);
  119.  
  120.     scratchlong = (long) gApplicationPrefs->SendTimeout;
  121.     NumToString(scratchlong,scratchPstring);
  122.     SetTEText(dptr,PrefSendTime, scratchPstring);
  123.  
  124.     ShowWindow(dptr);
  125.     ditem=0;                                /* initially no hits */
  126.     while((ditem>2) || (ditem==0)) {    
  127.         ModalDialog(DLOGwOK_CancelUPP,&ditem);
  128.         switch(ditem) {
  129.             case PrefDClose:
  130.             case PrefCMDkey:
  131.             case PrefTMap:
  132.             case PrefBlink:
  133.             case PrefNotifyUser:
  134.             case PrefKeyFuncMenus:
  135.             case PrefDestroyTickets:
  136.                 FlipCheckBox( dptr, ditem);
  137.                 break;
  138.             case PrefStag:
  139.                 FlipCheckBox( dptr, ditem);
  140.                 tempBoolean = !tempBoolean;
  141.                 if (!tempBoolean)
  142.                 {
  143.                     HideDItem(dptr,PrefStaggerOffset);
  144.                     HideDItem(dptr,PrefStaggerBY);
  145.                 }
  146.                 else
  147.                 {
  148.                     ShowDItem(dptr, PrefStaggerBY);
  149.                     ShowDItem(dptr, PrefStaggerOffset);
  150.                     scratchlong = gApplicationPrefs->StaggerWindowsOffset;
  151.                     NumToString(scratchlong, scratchPstring);
  152.                     SetTEText(dptr, PrefStaggerOffset, scratchPstring);
  153.                 }
  154.                 break;
  155.             case PrefBlockCursor:
  156.                 SetCntrl(dptr, PrefBlockCursor, 1);
  157.                 SetCntrl(dptr, PrefUnderscoreCursor, 0);
  158.                 SetCntrl(dptr, PrefVerticalCursor, 0);
  159.                 break;
  160.             case PrefUnderscoreCursor:
  161.                 SetCntrl(dptr, PrefBlockCursor, 0);
  162.                 SetCntrl(dptr, PrefUnderscoreCursor, 1);
  163.                 SetCntrl(dptr, PrefVerticalCursor, 0);
  164.                 break;
  165.             case PrefVerticalCursor:
  166.                 SetCntrl(dptr, PrefBlockCursor, 0);
  167.                 SetCntrl(dptr, PrefUnderscoreCursor, 0);
  168.                 SetCntrl(dptr, PrefVerticalCursor, 1);
  169.                 break;
  170.  
  171.             case PrefCaptCreat:
  172.                 GetApplicationType(&newtype);
  173.                 scratchPstring[0] = 4;
  174.                 BlockMove(&newtype, &scratchPstring[1], sizeof(OSType));
  175.                 SetTEText(dptr, PrefCaptTE, scratchPstring);
  176.                 break;
  177.             case PrefAnsiColor:
  178.                 AnsiPrompt();
  179.                 break;
  180.             default:
  181.                 break;
  182.             } /* switch */
  183.         }
  184.     
  185.     if (ditem==DLOGCancel) {
  186.             DisposDialog( dptr);
  187.             return;
  188.             }
  189.  
  190.     GetTEText(dptr, PrefCTt, scratchPstring);
  191.     StringToNum(scratchPstring, &scratchlong);
  192.     gApplicationPrefs->CopyTableThresh = (short) scratchlong;
  193.  
  194.     GetTEText(dptr, PrefTimeSlice, scratchPstring);
  195.     StringToNum(scratchPstring, &scratchlong);
  196.     BoundsCheck(&scratchlong, 100, 2);
  197.     gApplicationPrefs->TimeSlice = scratchlong;
  198.  
  199.     GetTEText(dptr,PrefOpenTime, scratchPstring);
  200.     StringToNum(scratchPstring, &scratchlong);
  201.     gApplicationPrefs->OpenTimeout = (short) scratchlong;
  202.     
  203.     GetTEText(dptr,PrefSendTime, scratchPstring);
  204.     StringToNum(scratchPstring, &scratchlong);
  205.     gApplicationPrefs->SendTimeout = (short) scratchlong;
  206.     
  207.     GetTEText(dptr, PrefCaptTE, scratchPstring);
  208.     BlockMove(&scratchPstring[1], &(gApplicationPrefs->CaptureFileCreator), sizeof(OSType));
  209.     GetTEText(dptr,PrefStaggerOffset, scratchPstring);
  210.     StringToNum(scratchPstring, &scratchlong);
  211.     gApplicationPrefs->StaggerWindowsOffset = (short) scratchlong;
  212.  
  213.     gApplicationPrefs->CommandKeys = GetCntlVal(dptr, PrefCMDkey);                    
  214.     gApplicationPrefs->WindowsDontGoAway = GetCntlVal(dptr, PrefDClose);
  215.     gApplicationPrefs->RemapTilde =    GetCntlVal(dptr, PrefTMap);
  216.     gApplicationPrefs->StaggerWindows = GetCntlVal(dptr, PrefStag);
  217.     gApplicationPrefs->BlinkCursor = GetCntlVal(dptr, PrefBlink);
  218.     gApplicationPrefs->KeyPadAndFuncMenus = GetCntlVal(dptr, PrefKeyFuncMenus);
  219.     gApplicationPrefs->NotifyUser = GetCntlVal(dptr,PrefNotifyUser);
  220.     gApplicationPrefs->destroyKTickets = GetCntlVal(dptr,PrefDestroyTickets);
  221.     gApplicationPrefs->CursorType = (GetCntlVal(dptr, PrefUnderscoreCursor) == 1) + (2 *
  222.                                      (GetCntlVal(dptr, PrefVerticalCursor) == 1));
  223.     
  224.     if (TelInfo->haveColorQuickDraw)
  225.     {
  226.         RSUpdatePalette(); //reflects any ANSI change
  227.                                      
  228.         UseResFile(TelInfo->SettingsFile);
  229.         toSave = (PaletteHandle) Get1Resource('pltt', 10000);
  230.         if (toSave == NULL)//this shouldnt happen; make a new copy
  231.         {
  232.             UseResFile(TelInfo->ApplicationFile);
  233.             toSave = (PaletteHandle)GetNewPalette(9999);
  234.             UseResFile(TelInfo->SettingsFile);
  235.             AddResource((Handle)toSave, 'pltt', 10000, "\pANSI Colors");//make the new resource
  236.             UpdateResFile(TelInfo->SettingsFile);
  237.         }
  238.         CopyPalette(TelInfo->AnsiColors,toSave,0,0,8);
  239.         ChangedResource((Handle)toSave);
  240.         UpdateResFile(TelInfo->SettingsFile);
  241.         ReleaseResource((Handle)toSave);
  242.     }
  243.     
  244.     switchMenus(gApplicationPrefs->CommandKeys);
  245.     SaveAppPreferences();
  246.     
  247.     DisposDialog( dptr);
  248. }
  249.  
  250.  
  251. void Cftp(void)
  252. {
  253.     DialogPtr            dptr;
  254.     short                ditem;
  255.     Str255                scratchPstring;
  256.     OSType                scratchOSType;
  257.     SFReply                sfr;
  258.     FInfo                fi;            
  259.     Point                where = {100,100};
  260.     
  261.     dptr = GetNewMySmallStrangeDialog( FTPDLOG, NULL, kInFront, (void *)ThirdCenterDialog);    
  262.  
  263.     SetCntrl(dptr, FTPServerOff, (gFTPServerPrefs->ServerState == 0));
  264.     SetCntrl(dptr, FTPServerUnsecure, (gFTPServerPrefs->ServerState == 1));
  265.     SetCntrl(dptr, FTPServerPswdPlease, (gFTPServerPrefs->ServerState == 2));
  266.     SetCntrl(dptr, FTPShowFTPlog, gFTPServerPrefs->ShowFTPlog);
  267.     SetCntrl(dptr, FTPrevDNS, gFTPServerPrefs->DNSlookupconnections);
  268.     SetCntrl(dptr, FTPUseMacBinaryII, gFTPServerPrefs->UseMacBinaryII);
  269.     SetCntrl(dptr, FTPResetMacBinary, gFTPServerPrefs->ResetMacBinary);
  270.     SetCntrl(dptr, FTPISO, gFTPServerPrefs->DoISOtranslation);
  271.  
  272.     HideDItem(dptr, FTPrevDNS);        // Sometime later, perhaps.
  273.     
  274.     scratchPstring[0] = 4;
  275.  
  276.     BlockMove(&(gFTPServerPrefs->BinaryCreator), &scratchPstring[1], sizeof(OSType));
  277.     SetTEText(dptr, FTPbincreatTE, scratchPstring);
  278.     
  279.     BlockMove(&(gFTPServerPrefs->BinaryType), &scratchPstring[1], sizeof(OSType));
  280.     SetTEText(dptr, FTPbintypeTE, scratchPstring);
  281.     SelIText(dptr, FTPbintypeTE, 0, 32767);
  282.  
  283.     BlockMove(&(gFTPServerPrefs->TextCreator), &scratchPstring[1], sizeof(OSType));
  284.     SetTEText(dptr, FTPtextcreatTE, scratchPstring);
  285.  
  286.     ShowWindow(dptr);
  287.     ditem=0;                                    /* initially no hits */
  288.     while((ditem>2) || (ditem==0)) {    
  289.         ModalDialog(DLOGwOK_CancelUPP,&ditem);
  290.         switch(ditem) {
  291.             case    FTPShowFTPlog:
  292.             case    FTPrevDNS:
  293.             case    FTPUseMacBinaryII:
  294.             case    FTPResetMacBinary:
  295.             case    FTPISO:
  296.                 FlipCheckBox( dptr, ditem);
  297.                 break;
  298.  
  299.             case    FTPServerOff:
  300.                 SetCntrl(dptr, FTPServerOff, 1);
  301.                 SetCntrl(dptr, FTPServerUnsecure, 0);
  302.                 SetCntrl(dptr, FTPServerPswdPlease, 0);
  303.                 break;
  304.             case    FTPServerUnsecure:
  305.                 SetCntrl(dptr, FTPServerOff, 0);
  306.                 SetCntrl(dptr, FTPServerUnsecure, 1);
  307.                 SetCntrl(dptr, FTPServerPswdPlease, 0);
  308.                 break;
  309.             case    FTPServerPswdPlease:
  310.                 SetCntrl(dptr, FTPServerOff, 0);
  311.                 SetCntrl(dptr, FTPServerUnsecure, 0);
  312.                 SetCntrl(dptr, FTPServerPswdPlease, 1);
  313.                 break;
  314.  
  315.             case    FTPtextcreatorbutton:
  316.                 if (GetApplicationType(&scratchOSType)) {
  317.                     BlockMove(&scratchOSType, &scratchPstring[1], sizeof(OSType));
  318.                     SetTEText(dptr, FTPtextcreatTE, scratchPstring);
  319.                     }
  320.                 break;
  321.             
  322.             case    FTPbinexamplebutton:
  323.                 SFGetFile(where, NULL, NULL, -1, NULL, NULL, &sfr);
  324.                 if (sfr.good) {
  325.                     GetFInfo(sfr.fName, sfr.vRefNum, &fi);
  326.                     scratchPstring[0] = sizeof(OSType);
  327.                     BlockMove(&fi.fdCreator, &scratchPstring[1], sizeof(OSType));
  328.                     SetTEText(dptr, FTPbincreatTE, scratchPstring);
  329.                     BlockMove(&fi.fdType, &scratchPstring[1], sizeof(OSType));
  330.                     SetTEText(dptr, FTPbintypeTE, scratchPstring);
  331.                     }
  332.                 break;    
  333.             default:
  334.                 break;
  335.             } /* switch */
  336.         } /* while */
  337.     
  338.     if (ditem==DLOGCancel) {
  339.             DisposDialog( dptr);
  340.             return;
  341.             }
  342.  
  343.     gFTPServerPrefs->ServerState = GetCntlVal(dptr, FTPServerUnsecure) + 
  344.         GetCntlVal(dptr, FTPServerPswdPlease) * 2;
  345.     StartUpFTP();            // Make sure FTP server recognizes new mode.
  346.     
  347.     gFTPServerPrefs->ShowFTPlog = GetCntlVal(dptr, FTPShowFTPlog);
  348.     gFTPServerPrefs->DNSlookupconnections = GetCntlVal(dptr, FTPrevDNS);
  349.     gFTPServerPrefs->UseMacBinaryII = GetCntlVal(dptr, FTPUseMacBinaryII);
  350.     gFTPServerPrefs->ResetMacBinary = GetCntlVal(dptr, FTPResetMacBinary);
  351.     gFTPServerPrefs->DoISOtranslation = GetCntlVal(dptr, FTPISO);
  352.  
  353.     GetTEText(dptr, FTPbincreatTE, scratchPstring);
  354.     BlockMove(&scratchPstring[1], &(gFTPServerPrefs->BinaryCreator), sizeof(OSType));
  355.     
  356.     GetTEText(dptr, FTPbintypeTE, scratchPstring);
  357.     BlockMove(&scratchPstring[1], &(gFTPServerPrefs->BinaryType), sizeof(OSType));
  358.  
  359.     GetTEText(dptr, FTPtextcreatTE, scratchPstring);
  360.     BlockMove(&scratchPstring[1], &(gFTPServerPrefs->TextCreator), sizeof(OSType));
  361.  
  362.     SaveFTPPreferences();
  363.     
  364.     DisposDialog( dptr);
  365. }
  366.  
  367. Boolean GetApplicationType(OSType *type)
  368. {
  369.     SFTypeList types;
  370.     SFReply sfr;
  371.     FInfo fi;
  372.     Point where;
  373.     
  374.     SetPt(&where, 100, 100);
  375.     types[0] = 'APPL';
  376.     SFGetFile(where, NULL, NULL, 1, types, NULL, &sfr);
  377.     if (sfr.good) {
  378.         GetFInfo(sfr.fName, sfr.vRefNum, &fi);
  379.         BlockMove(&fi.fdCreator, type, sizeof(OSType));        // Copy the application creator type
  380.         }
  381.         
  382.     return(sfr.good);
  383. }
  384.  
  385. //    Our standard modal dialog filter with code for handling user items containing lists.
  386. SIMPLE_UPP(MyDlogWListFilter, ModalFilter);
  387. pascal short MyDlogWListFilter( DialogPtr dptr, EventRecord *evt, short *item)
  388. {
  389.     short key, iType;
  390.     Handle iHndl;
  391.     Rect iRect;
  392.     Point scratchPoint;
  393.     Cell tempCell;
  394.     static unsigned long lastTime = 0;
  395.     static char shortcut[] = {0,0,0,0,0,0,0,0,0,0,0};
  396.     SetPort(dptr);
  397.     if ((evt->what == keyDown)||(evt->what == autoKey)) 
  398.     {
  399.         key = evt->message & charCodeMask;
  400.         //keyCode = (evt->message >>8) & 0xff ;
  401.         if ((key == 0x0d) || (key == 0x03)) { // 0x0d == return, 0x03 == enter
  402.             *item = 1;                // ok
  403.             FlashButton(dptr, 1);
  404.             return(-1);
  405.             }
  406.         else if (evt->modifiers & cmdKey)
  407.         {
  408.             switch(evt->message & charCodeMask)
  409.             {
  410.                 case 'e':
  411.                     *item = kChange;
  412.                 break;
  413.                 case 'r':
  414.                     *item = kRemove;
  415.                 break;
  416.                 case 'n':
  417.                     *item = kNew;
  418.                 break;
  419.                 case 'd':
  420.                     *item = kDuplicate;
  421.                 break;
  422.                 default:
  423.                     return(FALSE);
  424.                 break;
  425.             }
  426.             FlashButton(dptr, *item);
  427.             return (-1);
  428.  
  429.         }
  430.         else // a normal key
  431.         {
  432.             char keyCode = (evt->message & keyCodeMask) >> 8;
  433.  
  434.             if (keyCode >=0x7B) //CCP: arrow keys
  435.             {
  436.                 tempCell.h = tempCell.v = 0;
  437.                 switch(keyCode)
  438.                 {
  439.                     case 0x7E: //up
  440.                     case 0x7B: //left
  441.                         if (LGetSelect(TRUE,&tempCell,currentList))
  442.                         {
  443.                             LSetSelect(FALSE,tempCell,currentList);//unselect it
  444.                             tempCell.v--;
  445.                         }
  446.                         else
  447.                             tempCell.v = 0;
  448.                     break;
  449.                     case 0x7D: //down
  450.                     case 0x7C: //right
  451.                         if (LGetSelect(TRUE,&tempCell,currentList))
  452.                         {
  453.                             LSetSelect(FALSE,tempCell,currentList);//unselect it
  454.                             tempCell.v++;
  455.                         }
  456.                         else
  457.                             tempCell.v = (**currentList).dataBounds.bottom - 1;
  458.                     break;
  459.                     default:
  460.                         return (FALSE);
  461.                     break;
  462.                 }
  463.                 if (tempCell.v > (**currentList).dataBounds.bottom - 1)
  464.                     tempCell.v = (**currentList).dataBounds.bottom - 1;
  465.                 if (tempCell.v < 0)
  466.                     tempCell.v = 0;
  467.                 LSetSelect(TRUE,tempCell,currentList);//select it
  468.                 LAutoScroll(currentList);
  469.                 Hilite(dptr, kRemove, 0);
  470.                 Hilite(dptr, kChange, 0);
  471.                 return(FALSE);
  472.             }
  473.             else  //CCP go to right list item based on keystroke
  474.             {
  475.                 if ((TickCount() - lastTime) > GetCaretTime() )
  476.                     shortcut[0] = 0;
  477.                 lastTime = TickCount();
  478.                 shortcut[(shortcut[0]++) +1] = key;
  479.                 tempCell.h = tempCell.v = 0;
  480.                 if (LGetSelect(TRUE,&tempCell,currentList))
  481.                     LSetSelect(FALSE,tempCell,currentList);
  482.                 tempCell.v = findClosestNodeIndex(currentHead,(StringPtr)shortcut);
  483.                 LSetSelect(TRUE,tempCell,currentList);
  484.                 LAutoScroll(currentList);
  485.                 if (shortcut[0] == 10)
  486.                     shortcut[0] = 0;
  487.                 Hilite(dptr, kRemove, 0);
  488.                 Hilite(dptr, kChange, 0);
  489.             }    
  490.         }
  491.     }
  492.     else if (evt->what == updateEvt) 
  493.     {
  494.         if ((WindowPtr)evt->message == dptr) 
  495.         {
  496.             GetDItem(dptr,1,&iType,&iHndl,&iRect);    // ok
  497.             PenSize(3,3);
  498.             InsetRect(&iRect,-4,-4);
  499.             FrameRoundRect(&iRect,16,16);
  500.         }
  501.     }
  502.     else if (evt->what == mouseDown) 
  503.     {
  504.         GetDItem(dptr, kItemList, &iType, &iHndl, &iRect);
  505.         scratchPoint = evt->where;
  506.         GlobalToLocal(&scratchPoint);
  507.         if (PtInRect(scratchPoint, &iRect)) 
  508.         {
  509.             *item = kItemList;
  510.             if (LClick(scratchPoint, evt->modifiers, (ListHandle)GetWRefCon(dptr))) 
  511.             {
  512.                 *item = kChange;
  513.                 FlashButton(dptr, kChange);
  514.             }    
  515.             return(-1);
  516.         }
  517.     }
  518.     
  519.     return(FALSE);
  520. }
  521.  
  522. Boolean isACopy(Str255 theName)
  523. {
  524.     Boolean yes=FALSE;
  525.     char copyString[] = "copy";    
  526.     p2cstr(theName);
  527.     if (strstr((char *)theName,copyString))
  528.         yes = TRUE;
  529.     c2pstr((char *)theName);
  530.     return(yes);
  531. }
  532.     
  533.  
  534. //    User Dialog Item Procedure for a list.  Assumes the Dialog's refcon contains the list
  535. //    handle.
  536. SIMPLE_UPP(listDitemproc, UserItem);
  537. pascal void    listDitemproc(DialogPtr theDlg, short itemNo)
  538. {
  539.     short        itemType;
  540.     Handle        ControlHndl;
  541.     Rect        scratchRect;
  542.     
  543.     GetDItem(theDlg, itemNo, &itemType, &ControlHndl, &scratchRect);
  544.     
  545.     PenNormal();
  546.     InsetRect(&scratchRect, -1, -1);
  547.     FrameRect(&scratchRect);
  548.     LUpdate(theDlg->visRgn, (ListHandle)GetWRefCon(theDlg));
  549. }
  550.  
  551. void    BoundsCheck(long *value, long high, long low)
  552. {
  553.     if (*value > high) *value = high;
  554.     if (*value < low) *value = low;
  555. }
  556.  
  557. #define kSCListMods lNoNilHilite+lOnlyOne
  558. void    EditConfigType(ResType ConfigResourceType, Boolean (*EditFunction)(StringPtr))
  559. {
  560.     DialogPtr    dptr;
  561.     Handle         iHndl;
  562.     short         iType, length, ditem,numberofitems, index;
  563.     Rect         ListBox, ListBounds;
  564.     Point         cellSize, theCell;
  565.     ListHandle    thelist;
  566.     Handle        ItemResource;
  567.     Str255        ItemName;
  568.     LinkedListNode *theHead, *leader;
  569.     
  570.     dptr = GetNewMySmallDialog(kItemDLOG, NULL, kInFront, (void *)ThirdCenterDialog);
  571.         
  572.     ditem = 3;
  573.  
  574.     GetDItem(dptr, kItemList, &iType, &iHndl, &ListBox);
  575.     SetDItem(dptr, kItemList, iType, (Handle)listDitemprocUPP, &ListBox);
  576.     
  577.     ListBox.right -= 15;        // Make room for scrollbar
  578.     SetRect(&ListBounds, 0,0,1,0);
  579.     SetPt(&cellSize,(ListBox.right-ListBox.left),16);
  580.     thelist = LNew(&ListBox, &ListBounds, cellSize, 0, (WindowPtr)dptr,0,0,0,1);
  581.     (*(thelist))->listFlags = kSCListMods;
  582.     
  583.     currentList = thelist;
  584.     SetWRefCon(dptr, (long)thelist);        // So the Ditem proc can find the list
  585.     
  586.     UseResFile(TelInfo->SettingsFile);
  587.     numberofitems = Count1Resources(ConfigResourceType);
  588.     if (numberofitems)
  589.         theHead = createSortedList(ConfigResourceType,numberofitems,"\p<Default>"); //now we have a sorted linked list of the names
  590.      else
  591.         theHead = NULL;
  592.     leader = theHead;
  593.     for(index = 1, theCell.v = 0, theCell.h = 0; index <= numberofitems;index++, theCell.v++) 
  594.     {
  595.         LAddRow(1,-1, thelist);
  596.         HLock((Handle)leader->name);
  597.         LSetCell(*(leader->name) +1, (*leader->name)[0], theCell, thelist);
  598.         HUnlock((Handle)leader->name);
  599.         leader = leader->next;
  600.     }
  601.     theCell.v = 0;
  602.     theCell.h = 0;
  603.     if (numberofitems) LSetSelect(1, theCell, thelist);
  604.     LDoDraw(1, thelist);
  605.     
  606.     currentHead = theHead; //let dialog filter know about the list
  607.     while (ditem > 1) {
  608.         ModalDialog(MyDlogWListFilterUPP, &ditem);
  609.         
  610.         switch(ditem) 
  611.         {
  612.             case kRemove:
  613.                 SetPt(&theCell, 0, 0);
  614.                 if (LGetSelect(TRUE, &theCell, thelist)) 
  615.                 {
  616.                     length = 254;
  617.                     LGetCell(ItemName+1, &length, theCell, thelist);
  618.                     ItemName[0] = (char)length;
  619.                     if (!(EqualString(ItemName, "\p<Default>", TRUE, FALSE))) 
  620.                     {
  621.                         deleteItem(&theHead,ItemName);//delete it from the linked list
  622.                         LDelRow(1,theCell.v,thelist);
  623.                         theCell.v--;
  624.                         LSetSelect(TRUE,theCell,thelist);
  625.                         UseResFile(TelInfo->SettingsFile);
  626.                         ItemResource = Get1NamedResource(ConfigResourceType, ItemName);
  627.                         RmveResource(ItemResource);
  628.                         ReleaseResource(ItemResource);
  629.                         UpdateResFile(TelInfo->SettingsFile);
  630.                     }
  631.                 }
  632.                 break;
  633.             
  634.             case kChange:
  635.                 SetPt(&theCell, 0, 0);
  636.                 if (LGetSelect(TRUE, &theCell, thelist)) 
  637.                 {
  638.                     short newPosition;
  639.                     length = 254;
  640.                     LGetCell(ItemName+1, &length, theCell, thelist);
  641.                     ItemName[0] = (char)length;
  642.                     leader = findNode(theHead,ItemName);
  643.                     
  644.                     if ((*EditFunction)((StringPtr)&ItemName)) 
  645.                     {
  646.                         if (!(EqualString(ItemName,*leader->name,TRUE,FALSE)))//new name
  647.                         {
  648.                             DisposeHandle((Handle)leader->name);
  649.                             leader->name = NewString(ItemName);//set the new name
  650.                             newPosition = reSortElement(&theHead,leader);//resort
  651.                             LDelRow(1,theCell.v,thelist);//delete the old row
  652.                             theCell.v = newPosition; 
  653.                             LAddRow(1,newPosition,thelist); //add a new row
  654.                             LSetCell(&ItemName[1], ItemName[0],theCell, thelist);//write the name in
  655.                             LSetSelect(TRUE,theCell,thelist);
  656.                         }
  657.                     }
  658.                 }
  659.             break;
  660.             
  661.             case kNew:        
  662.                 ItemName[0] = 0;                    // Signal new shortcut
  663.                 if ((*EditFunction)((StringPtr)&ItemName)) 
  664.                 {
  665.                     short whereAt = createNodeAndSort(&theHead, ItemName);
  666.                     if (LGetSelect(TRUE, &theCell, thelist)) 
  667.                         LSetSelect(FALSE,theCell,thelist); //turn off old selection
  668.                     theCell.v = LAddRow(1, whereAt, thelist);
  669.                     LSetCell(ItemName+1, Length(ItemName), theCell, thelist);
  670.                     LSetSelect(TRUE,theCell,thelist); //turn on new selection    
  671.                 }
  672.             break;
  673.             
  674.             case kDuplicate:
  675.                 SetPt(&theCell, 0, 0);
  676.                 if (LGetSelect(TRUE, &theCell, thelist)) 
  677.                 {
  678.                     Handle oldResource,newResource;
  679.                     unsigned char copyString[] = " copy";
  680.                     short resourceID;
  681.                     short index;
  682.                     length = 254;
  683.                     LGetCell(ItemName+1, &length, theCell, thelist);
  684.                     LSetSelect(FALSE,theCell,thelist);
  685.                     ItemName[0] = (char)length;
  686.                     leader = findNode(theHead,ItemName);
  687.                     UseResFile(TelInfo->SettingsFile);
  688.                     oldResource = GetNamedResource(ConfigResourceType,ItemName);
  689.                     if (!isACopy(ItemName))//add the copy extension
  690.                     {
  691.                         ItemName[0] += 5;
  692.                         BlockMoveData(copyString, &(ItemName[ItemName[0]-4]),5); 
  693.                     }
  694.                     getAUniqueName(theHead,ItemName);
  695.                     resourceID = UniqueID(ConfigResourceType);
  696.                     newResource = myNewHandle(GetHandleSize(oldResource));
  697.                     BlockMoveData(*oldResource,*newResource,GetHandleSize(newResource));
  698.                     AddResource((Handle)newResource, ConfigResourceType, resourceID, ItemName);
  699.                     UpdateResFile(TelInfo->SettingsFile);
  700.                     index = createNodeAndSort(¤tHead,ItemName);
  701.                     theCell.v = index; 
  702.                     LAddRow(1,index,thelist); //add a new row
  703.                     LSetCell(&ItemName[1], ItemName[0],theCell, thelist);//write the name in
  704.                     LSetSelect(TRUE,theCell,thelist);
  705.                     ReleaseResource((Handle)newResource);
  706.                     ReleaseResource((Handle)oldResource);
  707.                 }
  708.             break;
  709.             default:
  710.             break;
  711.         } // switch
  712.         
  713.         SetPt(&theCell, 0, 0);
  714.         if (LGetSelect(TRUE, &theCell, thelist)) {
  715.             Hilite(dptr, kRemove, 0);
  716.             Hilite(dptr, kChange, 0);
  717.             }
  718.         else {
  719.             Hilite(dptr, kRemove, 255);
  720.             Hilite(dptr, kChange, 255);
  721.             }
  722.         
  723.     } // while
  724.     
  725.     LDispose(thelist);
  726.     DisposDialog(dptr);
  727.     deleteList(&theHead);
  728. }
  729.  
  730. void ZeroNumOnly(void)
  731. {
  732.     short i;
  733.     
  734.     for(i=0; i<NUMONLYSIZE; i++) NumOnly[i]=0;
  735. }
  736.  
  737. Boolean InNumOnly(short item)
  738. {
  739.     short index = 1;
  740.     
  741.     while ((NumOnly[index] != item) && (NumOnly[index] != 0)) index++;
  742.     
  743.     return(NumOnly[index] == item);
  744. }
  745.  
  746. short        NumberOfColorBoxes;
  747. short        BoxColorItems[16];
  748. RGBColor    BoxColorData[16];
  749.  
  750. SIMPLE_UPP(ColorBoxItemProc, UserItem);
  751. pascal void    ColorBoxItemProc(DialogPtr theDlg, short itemNo)
  752. {
  753.     short        itemType, index = 0;
  754.     Handle        ControlHndl;
  755.     Rect        scratchRect;
  756.     RGBColor    rgb;
  757.  
  758.     GetDItem(theDlg, itemNo, &itemType, &ControlHndl, &scratchRect);
  759.     PenNormal();
  760.     FrameRect(&scratchRect);
  761.     InsetRect(&scratchRect, 1, 1);            // Why isn't this framing the boxes?
  762.     
  763.     GetForeColor(&rgb);
  764.  
  765.     while ((index < NumberOfColorBoxes) && (BoxColorItems[index] != itemNo)) index++;
  766.     
  767.     RGBForeColor(&BoxColorData[index]);        /* color corresponding to item */
  768.     PaintRect(&scratchRect);
  769.  
  770.     RGBForeColor(&rgb);            /* restore previous foreground color */
  771. }
  772.  
  773. SIMPLE_UPP(ColorBoxModalProc, ModalFilter);
  774. pascal short ColorBoxModalProc( DialogPtr dptr, EventRecord *evt, short *item)
  775. {
  776.     short keyCode, key, iType, index;
  777.     Handle    iHndl;
  778.     Rect    iRect;
  779.     
  780.     if ((evt->what == keyDown) || (evt->what == autoKey)) {
  781.         key = evt->message & charCodeMask;
  782.         keyCode = (evt->message >>8) & 0xff;
  783.         if ((key == 0x0d) || (key == 0x03)) { // 0x0d == return, 0x03 == enter
  784.             *item = DLOGOk;
  785.             return(-1);                /* BYU LSC - pascal doesn't like "1" as true */
  786.             }
  787.         if (((key == '.') && (evt->modifiers & cmdKey)) ||
  788.             ((key == 0x1b) && (keyCode == 0x35)) ) {    // 0x35 == escKey
  789.             *item = DLOGCancel;
  790.             return(-1);                /* BYU LSC - pascal doesn't like "1" as true */
  791.             }
  792.  
  793.         if ((key < '0' || key > '9') && 
  794.             !(key == 0x08 || key == 0x09 || (key > 0x1B && key < 0x20))
  795.             && InNumOnly(((DialogPeek)dptr)->editField + 1)) {
  796.                 /* Reject non-numbers for this TE */
  797.                 *item = NumOnly[0];    /* Kludge -- Return "safe" item */
  798.                 return(-1);
  799.                 }   
  800.            }
  801.            
  802.     if (evt->what == updateEvt) {
  803.         if ((WindowPtr)evt->message == dptr) {
  804.             GetDItem(dptr,DLOGOk,&iType,&iHndl,&iRect);    // ok
  805.             PenSize(3,3);
  806.             InsetRect(&iRect,-4,-4);
  807.             FrameRoundRect(&iRect,16,16);
  808.             for (index = 0; index < NumberOfColorBoxes; index++)
  809.                 ColorBoxItemProc(dptr, BoxColorItems[index]);        // update color boxes
  810.             }
  811.     }
  812.     
  813.     Stask();
  814.     return(FALSE);
  815. }
  816.  
  817. SIMPLE_UPP(TerminalModalProc, ModalFilter);
  818. pascal short TerminalModalProc( DialogPtr dptr, EventRecord *evt, short *item)
  819. {
  820.     if (evt->what == mouseDown) return(PopupMousedown(dptr, evt, item));
  821.  
  822.     return(ColorBoxModalProc(dptr, evt, item));
  823. }
  824.  
  825. SIMPLE_UPP(SessionModalProc, ModalFilter);
  826. pascal short SessionModalProc(DialogPtr dptr, EventRecord *evt, short *item)
  827. {
  828.     if ((evt->what == keyDown) || (evt->what == autoKey))
  829.         if ((evt->message & charCodeMask) == ' ') {
  830.             *item = NumOnly[0];    /* Kludge -- Return "safe" item */
  831.             return(-1);
  832.             }
  833.     
  834.     return(TerminalModalProc(dptr, evt, item));
  835. }
  836.  
  837. Boolean EditTerminal(StringPtr PrefRecordNamePtr)
  838. {
  839.     DialogPtr        dptr;
  840.     short            ditem, scratchshort, resourceID, i;
  841.     long            scratchlong;
  842.     ResType            scratchResType;
  843.     Boolean            IsNewPrefRecord, UserLikesNewColor,wasInAliasText;
  844.     TerminalPrefs**    TermPrefsHdl;
  845.     TerminalPrefs*    TermPrefsPtr;
  846.     Str255            scratchPstring;
  847.     RGBColor        scratchRGBcolor;
  848.     Point            ColorBoxPoint;
  849.     MenuHandle        WeNeedAFontMenuHandle;
  850.     popup TPopup[] = {{TermFontPopup, (MenuHandle) 0, 1},
  851.                         {0, (MenuHandle) 0, 0}};
  852.  
  853.     dptr = GetNewMySmallStrangeDialog(TermDLOG, NULL, kInFront, (void *)ThirdCenterDialog);
  854.     ditem = 3;
  855.     
  856.     WeNeedAFontMenuHandle = NewMenu(666, "\p");
  857.     //get the fonts from the font menu in the menu bar
  858.     scratchshort = CountMItems(myMenus[Font]);
  859.     for (i = 1; i <= scratchshort; i++)
  860.     {
  861.         GetItem(myMenus[Font],i,scratchPstring);
  862.         AppendMenu(WeNeedAFontMenuHandle,scratchPstring);
  863.     }
  864.  
  865.     TPopup[0].h = WeNeedAFontMenuHandle;
  866.     PopupInit(dptr, TPopup);
  867.     
  868.     if (PrefRecordNamePtr[0] != 0) {
  869.         IsNewPrefRecord = FALSE;
  870.         UseResFile(TelInfo->SettingsFile);
  871.         TermPrefsHdl = (TerminalPrefs **)Get1NamedResource(TERMINALPREFS_RESTYPE, PrefRecordNamePtr);
  872.         if (EqualString(PrefRecordNamePtr, "\p<Default>", FALSE, FALSE)) {
  873.             HideDItem(dptr, TermNameStatText);
  874.             HideDItem(dptr, TermName);
  875.             }
  876.         }
  877.     else { //make sure we have a unique name
  878.         TermPrefsHdl = GetDefaultTerminal();
  879.         IsNewPrefRecord = TRUE;
  880.         GetIndString(PrefRecordNamePtr, MISC_STRINGS, MISC_NEWTERM);
  881.         getAUniqueName(currentHead,PrefRecordNamePtr);    
  882.     }
  883.     HLock((Handle) TermPrefsHdl);
  884.     TermPrefsPtr = *TermPrefsHdl;
  885.     SetTEText(dptr, TermName, PrefRecordNamePtr);
  886.     SetCntrl(dptr, TermANSI, TermPrefsPtr->ANSIgraphics);
  887.     SetCntrl(dptr, TermXterm, TermPrefsPtr->Xtermsequences);
  888.     SetCntrl(dptr, Termvtwrap, TermPrefsPtr->vtwrap);
  889. //    SetCntrl(dptr, Termmeta, TermPrefsPtr->emacsmetakey);
  890.     SetCntrl(dptr, TermMetaIsCmdCntrol, (TermPrefsPtr->emacsmetakey == 1));
  891.     SetCntrl(dptr, TermMetaIsOption, (TermPrefsPtr->emacsmetakey == 2));
  892.     SetCntrl(dptr, TermMetaIsOff, (TermPrefsPtr->emacsmetakey == 0));
  893.     SetCntrl(dptr, Termarrow, TermPrefsPtr->emacsarrows);
  894.     SetCntrl(dptr, TermMAT, TermPrefsPtr->MATmappings);
  895.     SetCntrl(dptr, Termeightbit, TermPrefsPtr->eightbit);
  896.     SetCntrl(dptr, Termclearsave, TermPrefsPtr->clearsave);
  897.     SetCntrl(dptr, TermVT100, (TermPrefsPtr->vtemulation == 0));
  898.     SetCntrl(dptr, TermVT220, (TermPrefsPtr->vtemulation == 1));
  899.     SetCntrl(dptr, TermRemapKeypad, TermPrefsPtr->remapKeypad);
  900.     scratchlong = (long)(TermPrefsPtr->vtwidth);
  901.     NumToString(scratchlong, scratchPstring);
  902.     SetTEText(dptr, TermWidth, scratchPstring);
  903.     scratchlong = (short)(TermPrefsPtr->vtheight);
  904.     NumToString(scratchlong, scratchPstring);
  905.     SetTEText(dptr, TermHeight, scratchPstring);
  906.     scratchlong = TermPrefsPtr->fontsize;
  907.     NumToString(scratchlong, scratchPstring);
  908.     SetTEText(dptr, TermFontSize, scratchPstring);
  909.     scratchlong = TermPrefsPtr->numbkscroll;
  910.     NumToString(scratchlong, scratchPstring);
  911.     SetTEText(dptr, TermScrollback, scratchPstring);
  912.     SetTEText(dptr, TermAnswerback, TermPrefsPtr->AnswerBackMessage);
  913.     
  914.     for(scratchshort = CountMItems(TPopup[0].h); scratchshort; scratchshort--) {
  915.         GetItem(TPopup[0].h, scratchshort, scratchPstring);
  916.         if (EqualString(scratchPstring, (TermPrefsPtr->DisplayFont), TRUE, FALSE))
  917.             TPopup[0].choice = scratchshort;
  918.         }
  919.     
  920.     ZeroNumOnly();
  921.     NumOnly[0] = TermSafeItem;
  922.     NumOnly[1] = TermWidth; NumOnly[2] = TermHeight; NumOnly[3] = TermFontSize;
  923.     NumOnly[4] = TermScrollback;  NumOnly[5] = 0;
  924.     
  925.     if (TermPrefsPtr->vtemulation != 1)
  926.     {
  927.         //HideDItem(dptr,TermRemapKeypad);
  928.         HideDItem(dptr,TermMAT);
  929.     }
  930.     if (TelInfo->haveColorQuickDraw) {
  931.         for (scratchshort = 0, NumberOfColorBoxes = 4; scratchshort < NumberOfColorBoxes; scratchshort++) {
  932.             BoxColorItems[scratchshort] = TermNFcolor + scratchshort;
  933.             BlockMove(&(TermPrefsPtr->nfcolor) + scratchshort,
  934.                 &BoxColorData[scratchshort], sizeof(RGBColor));
  935.             UItemAssign( dptr, TermNFcolor + scratchshort, ColorBoxItemProcUPP);
  936.             }
  937.         }
  938.     else
  939.         NumberOfColorBoxes = 0;        // B&W machine
  940.         
  941.     ColorBoxPoint.h = 0;            // Have the color picker center the box on the main
  942.     ColorBoxPoint.v = 0;            // screen
  943.         
  944.     SelIText(dptr, TermName, 0, 32767);
  945.     ShowWindow(dptr);
  946.     wasInAliasText = FALSE;
  947.     while (ditem > 2) 
  948.     {
  949.         ModalDialog(TerminalModalProcUPP, &ditem);
  950.         if ((wasInAliasText)&&(ditem != TermName))
  951.         {
  952.             wasInAliasText = FALSE;
  953.             GetTEText(dptr, TermName,scratchPstring);
  954.             if (EqualString(scratchPstring,PrefRecordNamePtr,TRUE,FALSE))
  955.                 goto okayTermName;
  956.             if(findNode(currentHead,scratchPstring))  //we already have that name
  957.             {
  958.                 DialogPtr alertUser;
  959.                 short    alertDItem = 3;
  960.                 alertUser = GetNewMyDialog(kBadPrefNameDLOG, NULL, kInFront, (void *)ThirdCenterDialog);            
  961.                 while (alertDItem > 1)
  962.                 {
  963.                     ModalDialog(DLOGwOK_CancelUPP,&alertDItem);
  964.                     DisposeDialog(alertUser);
  965.                 }
  966.                 SetPort(dptr); //back to old dialog
  967.                 SetTEText(dptr,TermName,PrefRecordNamePtr);//set the string back to the original
  968.                 SelIText(dptr,TermName,0,32767);
  969.                 ditem = TermName; //so that if they hit ok or cancel, it doesn't kill the window
  970.             }
  971.             else
  972.                 goto okayTermName;
  973.         }
  974.         else
  975.         {
  976.                 okayTermName:
  977.             switch (ditem) {
  978.                 case    TermANSI:
  979.                 case    TermXterm:
  980.                 case    Termvtwrap:
  981.                 case    Termarrow:
  982.                 case    TermMAT:
  983.                 case    Termeightbit:
  984.                 case    Termclearsave:
  985.                 case     TermRemapKeypad:
  986.                     FlipCheckBox(dptr, ditem);
  987.                     break;
  988.                 
  989.                 case    TermVT100:
  990.                     SetCntrl(dptr, TermVT100, 1);
  991.                     SetCntrl(dptr, TermVT220, 0);
  992.                     SetTEText(dptr, TermAnswerback, "\pVT100");
  993.                     //HideDItem(dptr,TermRemapKeypad);
  994.                     HideDItem(dptr,TermMAT);
  995.                     break;
  996.     
  997.                 case    TermVT220:
  998.                     SetCntrl(dptr, TermVT100, 0);
  999.                     SetCntrl(dptr, TermVT220, 1);
  1000.                     SetTEText(dptr, TermAnswerback, "\pVT220");
  1001.                     //ShowDItem(dptr,TermRemapKeypad);
  1002.                     ShowDItem(dptr,TermMAT);
  1003.                     break;
  1004.                 case    TermMetaIsCmdCntrol:
  1005.                     SetCntrl(dptr, TermMetaIsOption, 0);
  1006.                     SetCntrl(dptr, TermMetaIsOff, 0);
  1007.                     SetCntrl(dptr, TermMetaIsCmdCntrol, 1);
  1008.                     break;
  1009.                 case    TermMetaIsOption:
  1010.                     SetCntrl(dptr, TermMetaIsOff, 0);
  1011.                     SetCntrl(dptr, TermMetaIsCmdCntrol, 0);
  1012.                     SetCntrl(dptr, TermMetaIsOption, 1);
  1013.                     break;
  1014.                 case    TermMetaIsOff:
  1015.                     SetCntrl(dptr, TermMetaIsCmdCntrol, 0);
  1016.                     SetCntrl(dptr, TermMetaIsOption, 0);
  1017.                     SetCntrl(dptr, TermMetaIsOff, 1);
  1018.                     break;
  1019.                 case    TermNFcolor:    
  1020.                 case    TermNBcolor:    
  1021.                 case    TermBFcolor:    
  1022.                 case    TermBBcolor:    
  1023.                     if (TelInfo->haveColorQuickDraw) {
  1024.                         Str255 askColorString;
  1025.                         GetIndString(askColorString,MISC_STRINGS,PICK_NEW_COLOR_STRING);
  1026.                         UserLikesNewColor = GetColor(ColorBoxPoint, askColorString,
  1027.                              &BoxColorData[ditem-TermNFcolor], &scratchRGBcolor);
  1028.                         if (UserLikesNewColor)
  1029.                             BoxColorData[ditem-TermNFcolor] = scratchRGBcolor;
  1030.                         }
  1031.                     break;
  1032.                 case     TermName:
  1033.                     wasInAliasText = TRUE;
  1034.                 default:
  1035.                     break;
  1036.                 
  1037.                 } // switch
  1038.             }//else not wasInAliasText
  1039.         } // while
  1040.             
  1041.     GetItem(TPopup[0].h, TPopup[0].choice, scratchPstring);
  1042.     PopupCleanup();
  1043.     
  1044.     if (ditem == 2) {
  1045.         if (IsNewPrefRecord) DisposeHandle((Handle) TermPrefsHdl);
  1046.         else ReleaseResource((Handle) TermPrefsHdl);
  1047.         
  1048.         DisposeDialog(dptr);
  1049.         return(FALSE);            // No changes should be made.
  1050.         }
  1051.     
  1052.         
  1053.     if (TelInfo->haveColorQuickDraw) {
  1054.         for (scratchshort = 0; scratchshort < NumberOfColorBoxes; scratchshort++) {
  1055.                 BlockMove(&BoxColorData[scratchshort], 
  1056.                     &(TermPrefsPtr->nfcolor) + scratchshort, sizeof(RGBColor));
  1057.             }
  1058.         }
  1059.         
  1060.     if (Length(scratchPstring) > 63) scratchPstring[0] = 63;
  1061.     BlockMove(scratchPstring, (TermPrefsPtr->DisplayFont), scratchPstring[0]+1);
  1062.     
  1063.     TermPrefsPtr->ANSIgraphics = GetCntlVal(dptr, TermANSI);
  1064.     TermPrefsPtr->Xtermsequences = GetCntlVal(dptr, TermXterm);
  1065.     TermPrefsPtr->vtwrap = GetCntlVal(dptr, Termvtwrap);
  1066.  
  1067.     if (GetCntlVal(dptr, TermMetaIsCmdCntrol))
  1068.         TermPrefsPtr->emacsmetakey = 1;
  1069.     else if (GetCntlVal(dptr, TermMetaIsOption))
  1070.         TermPrefsPtr->emacsmetakey = 2;
  1071.     else
  1072.         TermPrefsPtr->emacsmetakey = 0;
  1073.     
  1074.     TermPrefsPtr->emacsarrows = GetCntlVal(dptr, Termarrow);
  1075.     TermPrefsPtr->MATmappings = GetCntlVal(dptr, TermMAT);
  1076.     TermPrefsPtr->eightbit = GetCntlVal(dptr, Termeightbit);
  1077.     TermPrefsPtr->clearsave = GetCntlVal(dptr, Termclearsave);
  1078.     TermPrefsPtr->remapKeypad = GetCntlVal(dptr, TermRemapKeypad);
  1079.     TermPrefsPtr->vtemulation = (GetCntlVal(dptr, TermVT220) != 0);
  1080.  
  1081.     GetTEText(dptr, TermWidth, scratchPstring);
  1082.     StringToNum(scratchPstring, &scratchlong);
  1083.     BoundsCheck(&scratchlong, 133, 10);
  1084.     TermPrefsPtr->vtwidth = (short) scratchlong;
  1085.     
  1086.     GetTEText(dptr, TermHeight, scratchPstring);
  1087.     StringToNum(scratchPstring, &scratchlong);
  1088.     BoundsCheck(&scratchlong, 80, 10);
  1089.     TermPrefsPtr->vtheight = (short) scratchlong;
  1090.  
  1091.     GetTEText(dptr, TermFontSize, scratchPstring);
  1092.     StringToNum(scratchPstring, &scratchlong);
  1093.     BoundsCheck(&scratchlong, 24, 4);
  1094.     TermPrefsPtr->fontsize = (short) scratchlong;
  1095.  
  1096.     GetTEText(dptr, TermScrollback, scratchPstring);
  1097.     StringToNum(scratchPstring, &scratchlong);
  1098.     BoundsCheck(&scratchlong, 50000, 24);
  1099.     TermPrefsPtr->numbkscroll = (short) scratchlong;
  1100.  
  1101.     GetTEText(dptr, TermAnswerback, scratchPstring);
  1102.     if (Length(scratchPstring) > 63) scratchPstring[0] = 63;
  1103.     BlockMove(scratchPstring, TermPrefsPtr->AnswerBackMessage, scratchPstring[0]+1);
  1104.     
  1105.     GetTEText(dptr, TermName, PrefRecordNamePtr);
  1106.     
  1107.     if (IsNewPrefRecord) {
  1108.         UseResFile(TelInfo->SettingsFile);
  1109.         resourceID = UniqueID(TERMINALPREFS_RESTYPE);
  1110.         AddResource((Handle)TermPrefsHdl, TERMINALPREFS_RESTYPE, resourceID, PrefRecordNamePtr);
  1111.         UpdateResFile(TelInfo->SettingsFile);
  1112.         ReleaseResource((Handle)TermPrefsHdl);
  1113.         }
  1114.     else {
  1115.         UseResFile(TelInfo->SettingsFile);
  1116.         GetResInfo((Handle)TermPrefsHdl, &resourceID, &scratchResType,(StringPtr) &scratchPstring);
  1117.         SetResInfo((Handle)TermPrefsHdl, resourceID, PrefRecordNamePtr);
  1118.         ChangedResource((Handle)TermPrefsHdl);
  1119.         UpdateResFile(TelInfo->SettingsFile);
  1120.         ReleaseResource((Handle)TermPrefsHdl);
  1121.         }
  1122.     
  1123.     DisposeDialog(dptr);
  1124.     return(TRUE);            // A resource has changed or been added.    
  1125. }
  1126.  
  1127. Boolean EditSession(StringPtr PrefRecordNamePtr)
  1128. {
  1129.     DialogPtr        dptr;
  1130.     short            ditem, scratchshort, resourceID;
  1131.     short             numberOfTerms;
  1132.     long            scratchlong;
  1133.     ResType            scratchResType;
  1134.     Boolean            IsNewPrefRecord, wasInAliasText;
  1135.     SessionPrefs**    SessPrefsHdl;
  1136.     SessionPrefs*    SessPrefsPtr;
  1137.     Str255            scratchPstring, scratchPstring2;
  1138.     LinkedListNode *savedList; 
  1139.     popup SPopup[] = {{SessTermPopup, (MenuHandle) 0, 1},
  1140.                         {SessTransTablePopup, (MenuHandle) 0, 1},
  1141.                         {0, (MenuHandle) 0, 0}};
  1142.  
  1143.     dptr = GetNewMySmallStrangeDialog(SessionConfigDLOG, NULL, kInFront, (void *)ThirdCenterDialog);
  1144.     ditem = 3;
  1145.     
  1146.     savedList = currentHead; //save the current list, so the list that got us here works
  1147.     SPopup[0].h = NewMenu(666, "\p");
  1148.     UseResFile(TelInfo->SettingsFile);
  1149.     numberOfTerms = Count1Resources(TERMINALPREFS_RESTYPE);
  1150.     currentHead  = createSortedList(TERMINALPREFS_RESTYPE,numberOfTerms,"\p<Default>");
  1151.     addListToMenu(SPopup[0].h, currentHead);
  1152.     EnableItem(SPopup[0].h, 0);        // Make sure the entire menu is enabled
  1153.     deleteList(¤tHead);
  1154.     
  1155.     UseResFile(TelInfo->ApplicationFile);
  1156.     SPopup[1].h = NewMenu(667, "\p");
  1157.     numberOfTerms = Count1Resources(USER_TRSL);
  1158.     currentHead  = createSortedList(USER_TRSL,numberOfTerms,NULL);
  1159.     GetIndString(scratchPstring,MISC_STRINGS,NONE_STRING); //"None" string
  1160.     AppendMenu(SPopup[1].h,scratchPstring);
  1161.     addListToMenu(SPopup[1].h, currentHead);
  1162.     EnableItem(SPopup[1].h, 0);        // Make sure the entire menu is enabled
  1163.     deleteList(¤tHead);
  1164.  
  1165.     UseResFile(TelInfo->SettingsFile);
  1166.     currentHead = savedList;
  1167.     PopupInit(dptr, SPopup);
  1168.     
  1169.     if (PrefRecordNamePtr[0] != 0) {
  1170.         IsNewPrefRecord = FALSE;
  1171.         UseResFile(TelInfo->SettingsFile);
  1172.         SessPrefsHdl = (SessionPrefs **)Get1NamedResource(SESSIONPREFS_RESTYPE, PrefRecordNamePtr);
  1173.         if (EqualString(PrefRecordNamePtr, "\p<Default>", FALSE, FALSE)) {
  1174.             HideDItem(dptr, SessAlias);
  1175.             HideDItem(dptr, SessAliasStatText);
  1176.             }
  1177.         }
  1178.     else {
  1179.         SessPrefsHdl = GetDefaultSession();
  1180.         IsNewPrefRecord = TRUE;
  1181.         GetIndString(PrefRecordNamePtr, MISC_STRINGS, MISC_NEWSESSION);
  1182.         getAUniqueName(currentHead,PrefRecordNamePtr);
  1183.     }    
  1184.     HLock((Handle) SessPrefsHdl);
  1185.     SessPrefsPtr = *SessPrefsHdl;
  1186.     SetCntrl(dptr, SessTEKinhib, (SessPrefsPtr->tektype == -1));
  1187.     SetCntrl(dptr, SessTEK4014, (SessPrefsPtr->tektype == 0));
  1188.     SetCntrl(dptr, SessTEK4105, (SessPrefsPtr->tektype == 1));
  1189.     SetCntrl(dptr, SessPasteQuick, (SessPrefsPtr->pastemethod == 0));
  1190.     SetCntrl(dptr, SessPasteBlock, (SessPrefsPtr->pastemethod == 1));
  1191.     SetCntrl(dptr, SessDeleteDel, (SessPrefsPtr->bksp == 1));
  1192.     SetCntrl(dptr, SessDeleteBS, (SessPrefsPtr->bksp == 0));
  1193.     SetCntrl(dptr, SessForceSave, SessPrefsPtr->forcesave);
  1194.     SetCntrl(dptr, SessBezerkeley, SessPrefsPtr->crmap);
  1195.     SetCntrl(dptr, SessLinemode, SessPrefsPtr->linemode);
  1196.     SetCntrl(dptr, SessTEKclear, SessPrefsPtr->tekclear);
  1197.     SetCntrl(dptr, SessHalfDuplex, SessPrefsPtr->halfdup);
  1198.     SetCntrl(dptr, SessAuthenticate, SessPrefsPtr->authenticate);
  1199.     SetCntrl(dptr, SessEncrypt, SessPrefsPtr->encrypt);
  1200.     SetCntrl(dptr, SessLocalEcho, SessPrefsPtr->localecho);
  1201.     SetTEText(dptr, SessHostName, SessPrefsPtr->hostname);
  1202.     SetTEText(dptr, SessAlias, PrefRecordNamePtr);
  1203.     NumToString(SessPrefsPtr->port, scratchPstring);
  1204.     SetTEText(dptr, SessPort, scratchPstring);
  1205.     NumToString(SessPrefsPtr->pasteblocksize, scratchPstring);
  1206.     SetTEText(dptr, SessBlockSize, scratchPstring);
  1207.     
  1208.     if (SessPrefsPtr->NetBlockSize <= 512)
  1209.         SessPrefsPtr->NetBlockSize = 512;
  1210.     NumToString(SessPrefsPtr->NetBlockSize, scratchPstring);
  1211.     SetTEText(dptr, SessBlockSizeTE, scratchPstring);
  1212.     
  1213.     scratchPstring[0] = 2;
  1214.     scratchPstring[1] = '^';
  1215.     if (SessPrefsPtr->ckey != -1) {
  1216.         scratchPstring[2] = SessPrefsPtr->ckey ^ 64;
  1217.         SetTEText(dptr, SessInterrupt, scratchPstring);
  1218.         }
  1219.     if (SessPrefsPtr->skey != -1) {
  1220.         scratchPstring[2] = SessPrefsPtr->skey ^ 64;
  1221.         SetTEText(dptr, SessSuspend, scratchPstring);
  1222.         }
  1223.     if (SessPrefsPtr->qkey != -1) {
  1224.         scratchPstring[2] = SessPrefsPtr->qkey ^ 64;
  1225.         SetTEText(dptr, SessResume, scratchPstring);
  1226.         }
  1227.     for(scratchshort = CountMItems(SPopup[0].h); scratchshort; scratchshort--) {
  1228.         GetItem(SPopup[0].h, scratchshort, scratchPstring);
  1229.         if (EqualString(scratchPstring, (SessPrefsPtr->TerminalEmulation), TRUE, FALSE))
  1230.             SPopup[0].choice = scratchshort;
  1231.         }
  1232.     for(scratchshort = CountMItems(SPopup[1].h); scratchshort; scratchshort--) {
  1233.         GetItem(SPopup[1].h, scratchshort, scratchPstring);
  1234.         if (EqualString(scratchPstring, (SessPrefsPtr->TranslationTable), TRUE, FALSE))
  1235.             SPopup[1].choice = scratchshort;
  1236.         }
  1237.     
  1238.     NumberOfColorBoxes = 0;
  1239.     ZeroNumOnly();
  1240.     NumOnly[0] = SessSafeItem;
  1241.     NumOnly[1] = SessPort;  NumOnly[2] = SessBlockSize;
  1242.     
  1243.     SelIText(dptr, SessAlias, 0, 32767);
  1244.     ShowWindow(dptr);
  1245.     wasInAliasText = FALSE;
  1246.     while (ditem > 2) {
  1247.         ModalDialog(SessionModalProcUPP, &ditem);
  1248.         if ((wasInAliasText)&&(ditem != SessAlias))
  1249.         {
  1250.             wasInAliasText = FALSE;
  1251.             GetTEText(dptr, SessAlias,scratchPstring);
  1252.             if (EqualString(scratchPstring,PrefRecordNamePtr,TRUE,FALSE))
  1253.                 goto okaySessName;
  1254.             if(findNode(currentHead,scratchPstring))  //we already have that name
  1255.             {
  1256.                 DialogPtr alertUser;
  1257.                 short    alertDItem = 3;
  1258.                 alertUser = GetNewMyDialog(kBadPrefNameDLOG, NULL, kInFront, (void *)ThirdCenterDialog);            
  1259.                 while (alertDItem > 1)
  1260.                 {
  1261.                     ModalDialog(DLOGwOK_CancelUPP,&alertDItem);
  1262.                     DisposeDialog(alertUser);
  1263.                 }
  1264.                 SetPort(dptr); //back to old dialog
  1265.                 SetTEText(dptr,SessAlias,PrefRecordNamePtr);//set the string back to the original
  1266.                 SelIText(dptr,SessAlias,0,32767);
  1267.                 ditem = SessAlias; //so that if they hit ok or cancel, it doesn't kill the window
  1268.             }
  1269.             else
  1270.                 goto okaySessName;
  1271.         }
  1272.         else
  1273.         {
  1274.             okaySessName:
  1275.             switch (ditem) {
  1276.                 case    SessForceSave:
  1277.                 case    SessBezerkeley:
  1278.                 case    SessLinemode:
  1279.                 case    SessTEKclear:
  1280.                 case    SessHalfDuplex:
  1281.                 case    SessAuthenticate:
  1282.                 case    SessEncrypt:
  1283.                 case    SessLocalEcho:
  1284.                     FlipCheckBox(dptr, ditem);
  1285.                     break;
  1286.                 
  1287.                 
  1288.                 case    SessTEKinhib:
  1289.                     SetCntrl(dptr, SessTEKinhib, 1);
  1290.                     SetCntrl(dptr, SessTEK4014, 0);
  1291.                     SetCntrl(dptr, SessTEK4105, 0);
  1292.                     break;
  1293.                 case    SessTEK4014:
  1294.                     SetCntrl(dptr, SessTEKinhib, 0);
  1295.                     SetCntrl(dptr, SessTEK4014, 1);
  1296.                     SetCntrl(dptr, SessTEK4105, 0);
  1297.                     break;
  1298.                 case    SessTEK4105:
  1299.                     SetCntrl(dptr, SessTEKinhib, 0);
  1300.                     SetCntrl(dptr, SessTEK4014, 0);
  1301.                     SetCntrl(dptr, SessTEK4105, 1);
  1302.                     break;
  1303.                     
  1304.                 case    SessPasteQuick:
  1305.                     SetCntrl(dptr, SessPasteQuick, 1);
  1306.                     SetCntrl(dptr, SessPasteBlock, 0);
  1307.                     break;
  1308.         
  1309.                 case    SessPasteBlock:
  1310.                     SetCntrl(dptr, SessPasteQuick, 0);
  1311.                     SetCntrl(dptr, SessPasteBlock, 1);
  1312.                     break;
  1313.         
  1314.                 case    SessDeleteDel:
  1315.                     SetCntrl(dptr, SessDeleteDel, 1);
  1316.                     SetCntrl(dptr, SessDeleteBS, 0);
  1317.                     break;
  1318.         
  1319.                 case    SessDeleteBS:
  1320.                     SetCntrl(dptr, SessDeleteDel, 0);
  1321.                     SetCntrl(dptr, SessDeleteBS, 1);
  1322.                     break;
  1323.         
  1324.                 case    SessInterrupt:
  1325.                 case    SessSuspend:
  1326.                 case    SessResume:
  1327.                     GetTEText(dptr, ditem, scratchPstring);
  1328.                     if ((scratchPstring[1] < 32) && (scratchPstring[1] > 0)) {
  1329.                         scratchPstring[0] = 2;
  1330.                         scratchPstring[2] = scratchPstring[1] ^ 64;
  1331.                         scratchPstring[1] = '^';
  1332.                         SetTEText(dptr, ditem, scratchPstring);
  1333.                         }
  1334.                     break;
  1335.                 case    SessAlias:
  1336.                     wasInAliasText = TRUE;
  1337.                     break;
  1338.                 default:
  1339.                     break;
  1340.                 } // switch
  1341.             } //else not bad alias
  1342.         } // while
  1343.         
  1344.     GetItem(SPopup[0].h, SPopup[0].choice, scratchPstring);
  1345.     GetItem(SPopup[1].h, SPopup[1].choice, scratchPstring2);
  1346.     PopupCleanup();
  1347.  
  1348.     if (ditem == 2) {
  1349.         if (IsNewPrefRecord) DisposeHandle((Handle) SessPrefsHdl);
  1350.         else ReleaseResource((Handle) SessPrefsHdl);
  1351.         DisposeDialog(dptr);
  1352.         return(FALSE);            // No changes should be made.
  1353.         }
  1354.         
  1355.     if (Length(scratchPstring) > 63) scratchPstring[0] = 63;
  1356.     BlockMove(scratchPstring, (SessPrefsPtr->TerminalEmulation), scratchPstring[0]+1);
  1357.  
  1358.     if (Length(scratchPstring2) > 63) scratchPstring[0] = 63;
  1359.     BlockMove(scratchPstring2, (SessPrefsPtr->TranslationTable), scratchPstring2[0]+1);
  1360.  
  1361.     SessPrefsPtr->tektype = (-1 * GetCntlVal(dptr, SessTEKinhib)) + GetCntlVal(dptr, SessTEK4105);
  1362.     SessPrefsPtr->pastemethod = !GetCntlVal(dptr, SessPasteQuick);
  1363.     SessPrefsPtr->bksp = GetCntlVal(dptr, SessDeleteDel);
  1364.     SessPrefsPtr->forcesave = GetCntlVal(dptr, SessForceSave);
  1365.     SessPrefsPtr->crmap = GetCntlVal(dptr, SessBezerkeley);
  1366.     SessPrefsPtr->linemode = GetCntlVal(dptr, SessLinemode);
  1367.     SessPrefsPtr->tekclear = GetCntlVal(dptr, SessTEKclear);
  1368.     SessPrefsPtr->halfdup = GetCntlVal(dptr, SessHalfDuplex);
  1369.     SessPrefsPtr->authenticate = GetCntlVal(dptr, SessAuthenticate);
  1370.     SessPrefsPtr->encrypt = GetCntlVal(dptr, SessEncrypt);
  1371.     SessPrefsPtr->localecho = GetCntlVal(dptr, SessLocalEcho);
  1372.  
  1373.     GetTEText(dptr, SessPort, scratchPstring);
  1374.     StringToNum(scratchPstring, &scratchlong);
  1375.     BoundsCheck(&scratchlong, 65530, 1);
  1376.     SessPrefsPtr->port = (short) scratchlong;
  1377.  
  1378.     GetTEText(dptr, SessBlockSize, scratchPstring);
  1379.     StringToNum(scratchPstring, &scratchlong);
  1380.     BoundsCheck(&scratchlong, 4097, 10);
  1381.     SessPrefsPtr->pasteblocksize = (short) scratchlong;
  1382.  
  1383.     GetTEText(dptr, SessHostName, scratchPstring);
  1384.     if (Length(scratchPstring) > 63) scratchPstring[0] = 63;
  1385.     BlockMove(scratchPstring, SessPrefsPtr->hostname, scratchPstring[0]+1);
  1386.     
  1387.     GetTEText(dptr, SessHostName, scratchPstring);
  1388.     if (Length(scratchPstring) > 63) scratchPstring[0] = 63;
  1389.     BlockMove(scratchPstring, SessPrefsPtr->hostname, scratchPstring[0]+1);
  1390.  
  1391.     GetTEText(dptr, SessAlias, PrefRecordNamePtr);
  1392.  
  1393.     GetTEText(dptr, SessInterrupt, scratchPstring);
  1394.     if (scratchPstring[0]) SessPrefsPtr->ckey = toupper(scratchPstring[2]) ^ 64;
  1395.     else SessPrefsPtr->ckey = -1;
  1396.     
  1397.     GetTEText(dptr, SessSuspend, scratchPstring);
  1398.     if (scratchPstring[0]) SessPrefsPtr->skey = toupper(scratchPstring[2]) ^ 64;
  1399.     else SessPrefsPtr->skey = -1;
  1400.     
  1401.     GetTEText(dptr, SessResume, scratchPstring);
  1402.     if (scratchPstring[0]) SessPrefsPtr->qkey = toupper(scratchPstring[2]) ^ 64;
  1403.     else SessPrefsPtr->qkey = -1;
  1404.     
  1405.     GetTEText(dptr,SessBlockSizeTE,scratchPstring);
  1406.     StringToNum(scratchPstring,&scratchlong);
  1407.     BoundsCheck(&scratchlong, 4096, 512);
  1408.     SessPrefsPtr->NetBlockSize = (short) scratchlong;
  1409.  
  1410.     if (IsNewPrefRecord) {
  1411.         UseResFile(TelInfo->SettingsFile);
  1412.         resourceID = UniqueID(SESSIONPREFS_RESTYPE);
  1413.         AddResource((Handle)SessPrefsHdl, SESSIONPREFS_RESTYPE, resourceID, PrefRecordNamePtr);
  1414.         UpdateResFile(TelInfo->SettingsFile);
  1415.         ReleaseResource((Handle)SessPrefsHdl);
  1416.         }
  1417.     else {
  1418.         UseResFile(TelInfo->SettingsFile);
  1419.         GetResInfo((Handle)SessPrefsHdl, &resourceID, &scratchResType,(StringPtr) &scratchPstring);
  1420.         SetResInfo((Handle)SessPrefsHdl, resourceID, PrefRecordNamePtr);
  1421.         ChangedResource((Handle)SessPrefsHdl);
  1422.         UpdateResFile(TelInfo->SettingsFile);
  1423.         ReleaseResource((Handle)SessPrefsHdl);
  1424.         }
  1425.     
  1426.     DisposeDialog(dptr);
  1427.     return(TRUE);            // A resource has changed or been added.    
  1428. }
  1429.  
  1430. Boolean EditFTPUser(StringPtr PrefRecordNamePtr)
  1431. {
  1432.     DialogPtr    dptr;
  1433.     short        ditem, scratchshort, resourceID, vRefNum;
  1434.     ResType        scratchResType;
  1435.     Boolean        IsNewPrefRecord;
  1436.     FTPUser**    FTPUHdl;
  1437.     FTPUser*    FTPUptr;
  1438.     Str255        scratchPstring, scratchPstring2;
  1439.  
  1440.     dptr = GetNewMySmallStrangeDialog(FTPUserDLOG, NULL, kInFront, (void *)ThirdCenterDialog);
  1441.     ditem = 3;
  1442.  
  1443.     HideDItem(dptr, FTPUcanchangeCWD);        // Sometime later, perhaps
  1444.         
  1445.     if (PrefRecordNamePtr[0] != 0) {
  1446.         IsNewPrefRecord = FALSE;
  1447.         UseResFile(TelInfo->SettingsFile);
  1448.         FTPUHdl = (FTPUser **)Get1NamedResource(FTPUSER, PrefRecordNamePtr);
  1449.         HLock((Handle) FTPUHdl);
  1450.         FTPUptr = *FTPUHdl;
  1451.         SetCntrl(dptr, FTPUcanchangeCWD, FTPUptr->UserCanCWD);
  1452.         SetTEText(dptr, FTPUusername, PrefRecordNamePtr);
  1453.         for (scratchshort = 8, scratchPstring[0] = 8; scratchshort > 0; scratchshort--)
  1454.             scratchPstring[scratchshort] = '•';
  1455.          SetTEText(dptr, FTPUpassword, scratchPstring);
  1456.         vRefNum = VolumeNameToRefNum(FTPUptr->DefaultDirVolName);
  1457.         }
  1458.     else {
  1459.         IsNewPrefRecord = TRUE;
  1460.         FTPUHdl = (FTPUser **)myNewHandle(sizeof(FTPUser));
  1461.         HLock((Handle) FTPUHdl);
  1462.         FTPUptr = *FTPUHdl;
  1463.         vRefNum = -1;                        // Default Volume
  1464.         FTPUptr->DefaultDirDirID = 2;        // Root directory
  1465.         SetCntrl(dptr, FTPUcanchangeCWD, 0);
  1466.         }
  1467.  
  1468.     PathNameFromDirID(FTPUptr->DefaultDirDirID, vRefNum, scratchPstring);
  1469.     SetTEText(dptr, FTPUDfltDirDsply, scratchPstring);
  1470.     
  1471.     SelIText(dptr, FTPUusername, 0, 32767);
  1472.     ShowWindow(dptr);
  1473.     
  1474.     while (ditem > 2) {
  1475.         ModalDialog(DLOGwOK_CancelUPP, &ditem);
  1476.         switch (ditem) {
  1477.             case    FTPUcanchangeCWD:
  1478.                 FlipCheckBox(dptr, ditem);
  1479.                 break;
  1480.             
  1481.             case    FTPUDfltDirButton:
  1482.                 SelectDirectory(&vRefNum, &(FTPUptr->DefaultDirDirID));
  1483.                 PathNameFromDirID(FTPUptr->DefaultDirDirID, vRefNum, scratchPstring);
  1484.                 SetTEText(dptr, FTPUDfltDirDsply, scratchPstring);
  1485.                 break;
  1486.                 
  1487.             default:
  1488.                 break;
  1489.             
  1490.             } // switch
  1491.         } // while
  1492.         
  1493.     if (ditem == 2) {
  1494.         if (IsNewPrefRecord) DisposeHandle((Handle) FTPUHdl);
  1495.         else ReleaseResource((Handle) FTPUHdl);
  1496.         
  1497.         DisposeDialog(dptr);
  1498.         return(FALSE);            // No changes should be made.
  1499.         }
  1500.         
  1501.     FTPUptr->UserCanCWD = GetCntlVal(dptr, FTPUcanchangeCWD);
  1502.     GetDirectoryName(vRefNum, 2, FTPUptr->DefaultDirVolName);
  1503.     
  1504.     GetTEText(dptr, FTPUusername, PrefRecordNamePtr);
  1505.     GetTEText(dptr, FTPUpassword, scratchPstring);
  1506.     
  1507.     if (scratchPstring[0] != '•') {
  1508.         // Encrypt the new (or possibly modified) password.
  1509.         PtoCstr(scratchPstring);
  1510.         Sencompass((char *)scratchPstring, (char *)scratchPstring2);
  1511.         CtoPstr((char *)scratchPstring2);
  1512.         BlockMove(scratchPstring2, FTPUptr->EncryptedPassword, Length(scratchPstring2)+1);
  1513.         }
  1514.             
  1515.     if (IsNewPrefRecord) {
  1516.         UseResFile(TelInfo->SettingsFile);
  1517.         resourceID = UniqueID(FTPUSER);
  1518.         AddResource((Handle)FTPUHdl, FTPUSER, resourceID, PrefRecordNamePtr);
  1519.         UpdateResFile(TelInfo->SettingsFile);
  1520.         ReleaseResource((Handle)FTPUHdl);
  1521.         }
  1522.     else {
  1523.         UseResFile(TelInfo->SettingsFile);
  1524.         GetResInfo((Handle)FTPUHdl, &resourceID, &scratchResType,(StringPtr) &scratchPstring);
  1525.         SetResInfo((Handle)FTPUHdl, resourceID, PrefRecordNamePtr);
  1526.         ChangedResource((Handle)FTPUHdl);
  1527.         UpdateResFile(TelInfo->SettingsFile);
  1528.         ReleaseResource((Handle)FTPUHdl);
  1529.         }
  1530.     
  1531.     DisposeDialog(dptr);
  1532.     return(TRUE);            // A resource has changed or been added.    
  1533. }
  1534.  
  1535. void AnsiPrompt(void)
  1536. {
  1537.   /* puts up the dialog that lets the user examine and change the ANSI color
  1538.     settings for the specified window. */
  1539.  
  1540.     short        scratchshort, ditem;
  1541.     Point            ColorBoxPoint;
  1542.     DialogPtr        dptr;
  1543.     Boolean            UserLikesNewColor;
  1544.     RGBColorPtr     scratchRGB;
  1545.         
  1546.     scratchRGB = (RGBColorPtr) myNewPtr(sizeof(RGBColor));
  1547.     dptr = GetNewMySmallDialog(ANSIColorDLOG, NULL, kInFront, (void *)ThirdCenterDialog);
  1548.     NumberOfColorBoxes = 6;
  1549.     for (scratchshort = 0; scratchshort < NumberOfColorBoxes; scratchshort++) 
  1550.     {
  1551.         BoxColorItems[scratchshort] = ANSIRed + scratchshort;
  1552.         GetEntryColor(TelInfo->AnsiColors, scratchshort + 1, scratchRGB);
  1553.         BlockMove(scratchRGB,&BoxColorData[scratchshort], sizeof(RGBColor));
  1554.         UItemAssign( dptr, scratchshort + ANSIRed, ColorBoxItemProcUPP);
  1555.     }
  1556.         
  1557.     ColorBoxPoint.h = 0;            // Have the color picker center the box on the main
  1558.     ColorBoxPoint.v = 0;            // screen
  1559.     NumOnly[0] = 12; //safe item
  1560.     ditem = 3;    
  1561.     while (ditem > 2) {
  1562.         ModalDialog(ColorBoxModalProcUPP, &ditem);
  1563.         switch (ditem) {
  1564.             case    ANSIRed:    
  1565.             case    ANSIGreen:    
  1566.             case    ANSIYellow:    
  1567.             case    ANSIBlue:    
  1568.             case    ANSIMagenta:    
  1569.             case    ANSICyan:    
  1570.                 if (TelInfo->haveColorQuickDraw) 
  1571.                 {
  1572.                     Str255 askColorString;
  1573.                     GetIndString(askColorString,MISC_STRINGS,PICK_NEW_COLOR_STRING);
  1574.                     UserLikesNewColor = GetColor(ColorBoxPoint,askColorString,
  1575.                          &BoxColorData[ditem-ANSIRed], scratchRGB);
  1576.                     if (UserLikesNewColor)
  1577.                         BoxColorData[ditem-ANSIRed] = *scratchRGB;
  1578.                 }
  1579.                 break;
  1580.                 
  1581.             default:
  1582.                 break;
  1583.             
  1584.             } // switch
  1585.         } // while
  1586.  
  1587.     if (ditem == DLOGCancel) 
  1588.     {
  1589.         DisposeDialog(dptr);
  1590.         return;
  1591.     }    
  1592.     for (scratchshort = 0; scratchshort < NumberOfColorBoxes; scratchshort++) 
  1593.         SetEntryColor(TelInfo->AnsiColors, scratchshort+1, &(BoxColorData[scratchshort]));
  1594.     
  1595.     DisposeDialog(dptr);
  1596. }
  1597.  
  1598.